#!BPY

"""
Name: 'Galaxy Mage Mesh and Animation (.gmm)...'
Blender: 245
Group: 'Export'
Tooltip: 'Save a GMM File'
"""

__author__ = "Campbell Barton, Jiri Hnidek, Markus Martin"
__url__ = ['www.blender.org', 'blenderartists.org', 'galaxymage.brandonbarnes.us']
__version__ = "1.0"

__bpydoc__ = """\
This script is an exporter to Galaxy Mage Mesh file format.

Usage:

Select the objects you wish to export and run this script from "File->Export" menu.
Selecting the default options from the popup box will be good in most cases.
All objects that can be represented as a mesh (mesh, curve, metaball, surface, text3d)
will be exported as mesh data.

Selecting an armature object will export animation data along with any actions in the
current scene. Currently materials are not supported. Make sure your objects are using
a material called 'Material' or fix things in the resulting file.
"""

# --------------------------------------------------------------------------
# GMM Export v0.1 by Markus Martin
# Derived from OBJ Export v1.1 by Campbell Barton (AKA Ideasman)
# --------------------------------------------------------------------------
# ***** BEGIN GPL LICENSE BLOCK *****
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation,
# Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
#
# ***** END GPL LICENCE BLOCK *****
# --------------------------------------------------------------------------

import Blender
from Blender import Mesh, Scene, Window, sys, Image, Draw
from Blender.Mathutils import Vector, Euler, Quaternion
from Blender.Armature import NLA
from Blender.Ipo import *
import BPyMesh
import BPyObject
import BPySys
import BPyMessages

VERSION = '0.1rc1' # File format version

# Returns a tuple - path,extension.
# 'hello.obj' >  ('hello', '.obj')
def splitExt(path):
    dotidx = path.rfind('.')
    if dotidx == -1:
        return path, ''
    else:
        return path[:dotidx], path[dotidx:] 

def fixName(name):
    if name == None:
        return 'None'
    else:
        return name.replace(' ', '_')

# A Dict of Materials
# (material.name, image.name):matname_imagename # matname_imagename has gaps removed.
MTL_DICT = {} 

def write_mtl(filename):
    
    world = Blender.World.GetCurrent()
    if world:
        worldAmb = world.getAmb()
    else:
        worldAmb = (0,0,0) # Default value
    
    file = open(filename, "w")
    file.write('# Blender3D MTL File: %s\n' % Blender.Get('filename').split('\\')[-1].split('/')[-1])
    file.write('# Material Count: %i\n' % len(MTL_DICT))
    # Write material/image combinations we have used.
    for key, (mtl_mat_name, mat, img) in MTL_DICT.iteritems():
        
        # Get the Blender data for the material and the image.
        # Having an image named None will make a bug, dont do it :)
        
        file.write('newmtl %s\n' % mtl_mat_name) # Define a new material: matname_imgname
        
        if mat:
            file.write('Ns %.6f\n' % ((mat.getHardness()-1) * 1.9607843137254901) ) # Hardness, convert blenders 1-511 to MTL's 
            file.write('Ka %.6f %.6f %.6f\n' %  tuple([c*mat.amb for c in worldAmb])  ) # Ambient, uses mirror colour,
            file.write('Kd %.6f %.6f %.6f\n' % tuple([c*mat.ref for c in mat.rgbCol]) ) # Diffuse
            file.write('Ks %.6f %.6f %.6f\n' % tuple([c*mat.spec for c in mat.specCol]) ) # Specular
            file.write('Ni %.6f\n' % mat.IOR) # Refraction index
            file.write('d %.6f\n' % mat.alpha) # Alpha (obj uses 'd' for dissolve)
            
            # 0 to disable lighting, 1 for ambient & diffuse only (specular color set to black), 2 for full lighting.
            if mat.getMode() & Blender.Material.Modes['SHADELESS']:
                file.write('illum 0\n') # ignore lighting
            elif mat.getSpec() == 0:
                file.write('illum 1\n') # no specular.
            else:
                file.write('illum 2\n') # light normaly 
        
        else:
            #write a dummy material here?
            file.write('Ns 0\n')
            file.write('Ka %.6f %.6f %.6f\n' %  tuple([c for c in worldAmb])  ) # Ambient, uses mirror colour,
            file.write('Kd 0.8 0.8 0.8\n')
            file.write('Ks 0.8 0.8 0.8\n')
            file.write('d 1\n') # No alpha
            file.write('illum 2\n') # light normaly
        
        # Write images!
        if img:  # We have an image on the face!
            file.write('map_Kd %s\n' % img.filename.split('\\')[-1].split('/')[-1]) # Diffuse mapping image         
        
        elif not mat: # No face image. if we havea material search for MTex image.
            for mtex in mat.getTextures():
                if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
                    try:
                        filename = mtex.tex.image.filename.split('\\')[-1].split('/')[-1]
                        file.write('map_Kd %s\n' % filename) # Diffuse mapping image
                        break
                    except:
                        # Texture has no image though its an image type, best ignore.
                        pass
        
        file.write('\n\n')
    
    file.close()

def copy_file(source, dest):
    file = open(source, 'rb')
    data = file.read()
    file.close()
    
    file = open(dest, 'wb')
    file.write(data)
    file.close()


def copy_images(dest_dir):
    if dest_dir[-1] != sys.sep:
        dest_dir += sys.sep
    
    # Get unique image names
    uniqueImages = {}
    for matname, mat, image in MTL_DICT.itervalues(): # Only use image name
        # Get Texface images
        if image:
            uniqueImages[image] = image # Should use sets here. wait until Python 2.4 is default.
        
        # Get MTex images
        if mat:
            for mtex in mat.getTextures():
                if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
                    image_tex = mtex.tex.image
                    if image_tex:
                        try:
                            uniqueImages[image_tex] = image_tex
                        except:
                            pass
    
    # Now copy images
    copyCount = 0
    
    for bImage in uniqueImages.itervalues():
        image_path = sys.expandpath(bImage.filename)
        if sys.exists(image_path):
            # Make a name for the target path.
            dest_image_path = dest_dir + image_path.split('\\')[-1].split('/')[-1]
            if not sys.exists(dest_image_path): # Image isnt alredy there
                print '\tCopying "%s" > "%s"' % (image_path, dest_image_path)
                copy_file(image_path, dest_image_path)
                copyCount+=1
    print '\tCopied %d images' % copyCount

def write(filename, objects,\
EXPORT_TRI=False,  EXPORT_EDGES=False,  EXPORT_NORMALS=False,  EXPORT_NORMALS_HQ=False,\
EXPORT_UV=True,  EXPORT_MTL=True,  EXPORT_COPY_IMAGES=False,\
EXPORT_APPLY_MODIFIERS=True, EXPORT_ROTX90=True, EXPORT_BLEN_OBS=True,\
EXPORT_GROUP_BY_OB=False,  EXPORT_GROUP_BY_MAT=False, EXPORT_MORPH_TARGET=False, EXPORT_ANIMATION=False):
    '''
    Basic write function. The context and options must be already set
    This can be accessed externally
    eg.
    write( '~/test/foobar.gmm', Blender.Object.GetSelected() ) # Using default options.
    '''
    
    def veckey3d(v):
        return round(v.x, 6), round(v.y, 6), round(v.z, 6)

    #def veckey2d(v):
    #   return round(v.x, 6), round(v.y, 6)
    
    print 'GMM Export path: "%s"' % filename
    temp_mesh_name = '~tmp-mesh'

    time1 = sys.time()
    scn = Scene.GetCurrent()

    file = open(filename, "w")
    
    # Write Header
    file.write('# Blender3D v%s GMM File: %s\n' % (Blender.Get('version'), Blender.Get('filename').split('/')[-1].split('\\')[-1] ))
    file.write('# www.blender3d.org\n')
    file.write('ver %s\n' % VERSION)

    # TODO: Remove temporary material hack
    file.write('mtl Material\n')
    file.write('mc Material 1.0 0 0 1.0\n')

    # Tell the obj file what material file to use.
#    if EXPORT_MTL: # TODO: clean this up
#        mtlfilename = '%s.mtl' % '.'.join(filename.split('.')[:-1])
#        file.write('mtllib %s\n' % ( mtlfilename.split('\\')[-1].split('/')[-1] ))
    
    # Get the container mesh. - used for applying modifiers and non mesh objects.
    containerMesh = meshName = tempMesh = None
    for meshName in Blender.NMesh.GetNames():
        if meshName.startswith(temp_mesh_name):
            tempMesh = Mesh.Get(meshName)
            if not tempMesh.users:
                containerMesh = tempMesh
    if not containerMesh:
        containerMesh = Mesh.New(temp_mesh_name)
    
    if EXPORT_ROTX90:
        mat_xrot90= Blender.Mathutils.RotationMatrix(-90, 4, 'x')
        
    del meshName
    del tempMesh
    
    # Initialize totals, these are updated each object
    totverts = totuvco = totno = 1
    
    face_vert_index = 1 # used for uvs now
    
    globalNormals = {}
    
    # Get all meshs
    for ob_main in objects:
        if ob_main.getType() == 'Armature' and EXPORT_ANIMATION:
            write_armature(file, ob_main) # write out bone structure
            continue

        for ob, ob_mat in BPyObject.getDerivedObjects(ob_main):
            # Will work for non meshes now! :)
            # getMeshFromObject(ob, container_mesh=None, apply_modifiers=True, vgroups=True, scn=None)
            me= BPyMesh.getMeshFromObject(ob, containerMesh, EXPORT_APPLY_MODIFIERS, False, scn)
            if not me:
                continue
            faceuv= me.faceUV
            
            # We have a valid mesh
            if EXPORT_TRI and me.faces:
                # Add a dummy object to it.
                has_quads = False
                for f in me.faces:
                    if len(f) == 4:
                        has_quads = True
                        break
                
                if has_quads:
                    oldmode = Mesh.Mode()
                    Mesh.Mode(Mesh.SelectModes['FACE'])
                    
                    me.sel = True
                    tempob = scn.objects.new(me)
                    me.quadToTriangle(0) # more=0 shortest length
                    oldmode = Mesh.Mode(oldmode)
                    scn.objects.unlink(tempob)
                    
                    Mesh.Mode(oldmode)
            
            # Make our own list so it can be sorted to reduce context switching
            faces = [ f for f in me.faces ]
            
            if EXPORT_EDGES:
                edges = me.edges
            else:
                edges = []
            
            if not (len(faces)+len(edges)+len(me.verts)): # Make sure there is somthing to write
                continue # dont bother with this mesh.
            
            if EXPORT_ROTX90:
                me.transform(ob_mat*mat_xrot90)
            else:
                me.transform(ob_mat)
            
            # High Quality Normals
            if EXPORT_NORMALS and faces:
                if EXPORT_NORMALS_HQ:
                    BPyMesh.meshCalcNormals(me)
                else:
                    # transforming normals is incorrect
                    # when the matrix is scaled,
                    # better to recalculate them
                    me.calcNormals()
            
            # # Crash Blender
            #materials = me.getMaterials(1) # 1 == will return None in the list.
            materials = me.materials
            
            materialNames = []
            materialItems = materials[:]
            if materials:
                for mat in materials:
                    if mat: # !=None
                        materialNames.append(mat.name)
                    else:
                        materialNames.append(None)
                # Cant use LC because some materials are None.
                # materialNames = map(lambda mat: mat.name, materials) # Bug Blender, dosent account for null materials, still broken.  
            
            # Possible there null materials, will mess up indicies
            # but at least it will export, wait until Blender gets fixed.
            materialNames.extend((16-len(materialNames)) * [None])
            materialItems.extend((16-len(materialItems)) * [None])
            
            # Sort by Material, then images
            # so we dont over context switch in the obj file.
            if EXPORT_MORPH_TARGET:
                pass
            elif faceuv and EXPORT_UV:
                try:    faces.sort(key = lambda a: (a.mat, a.image, a.smooth))
                except: faces.sort(lambda a,b: cmp((a.mat, a.image, a.smooth), (b.mat, b.image, b.smooth)))
            elif len(materials) > 1:
                try:    faces.sort(key = lambda a: (a.mat, a.smooth))
                except: faces.sort(lambda a,b: cmp((a.mat, a.smooth), (b.mat, b.smooth)))
            else:
                # no materials
                try:    faces.sort(key = lambda a: a.smooth)
                except: faces.sort(lambda a,b: cmp(a.smooth, b.smooth))
            
            # Set the default mat to no material and no image.
            contextMat = (0, 0) # Can never be this, so we will label a new material teh first chance we get.
            contextSmooth = None # Will either be true or false,  set bad to force initialization switch.
            
            if EXPORT_BLEN_OBS or EXPORT_GROUP_BY_OB:
                obnamestring = fixName(ob.name)
                
                if EXPORT_BLEN_OBS:
                    file.write('o %s\n' % obnamestring) # Write Object name
                else: # if EXPORT_GROUP_BY_OB:
                    file.write('g %s\n' % obnamestring)
            
            
            # Vert
            for v in me.verts:
                file.write('v %.6f %.6f %.6f\n' % tuple(v.co))
            
            # UV
            if faceuv and EXPORT_UV:
                for f in faces:
                    for uv in f.uv:
                        file.write('vt %.6f %.6f 0.0\n' % tuple(uv))
            
            # NORMAL, Smooth/Non smoothed.
            if EXPORT_NORMALS:
                for f in faces:
                    if f.smooth:
                        for v in f:
                            noKey = veckey3d(v.no)
                            if not globalNormals.has_key( noKey ):
                                globalNormals[noKey] = totno
                                totno +=1
                                file.write('vn %.6f %.6f %.6f\n' % noKey)
                    else:
                        # Hard, 1 normal from the face.
                        noKey = veckey3d(f.no)
                        if not globalNormals.has_key( noKey ):
                            globalNormals[noKey] = totno
                            totno +=1
                            file.write('vn %.6f %.6f %.6f\n' % noKey)
            if not faceuv:
                f_image = None
            
            for f in faces:
                f_v= f.v
                f_smooth= f.smooth
                f_mat = min(f.mat, len(materialNames)-1)
                if faceuv:
                    f_image = f.image
                    f_uv= f.uv
                
                # MAKE KEY
                if EXPORT_UV and faceuv and f_image: # Object is always true.
                    key = materialNames[f_mat],  f_image.name
                else:
                    key = materialNames[f_mat],  None # No image, use None instead.
                
                # CHECK FOR CONTEXT SWITCH
                if key == contextMat:
                    pass # Context alredy switched, dont do anythoing
                else:
                    if key[0] == None and key[1] == None:
                        # Write a null material, since we know the context has changed.
                        if EXPORT_GROUP_BY_MAT:
                            file.write('g %s_%s\n' % (fixName(ob.name), fixName(ob.getData(1))) ) # can be mat_image or (null)
                        file.write('usemtl (null)\n') # mat, image
                        
                    else:
                        mat_data= MTL_DICT.get(key)
                        if not mat_data:
                            # First add to global dict so we can export to mtl
                            # Then write mtl
                            
                            # Make a new names from the mat and image name,
                            # converting any spaces to underscores with fixName.
                            
                            # If none image dont bother adding it to the name
                            if key[1] == None:
                                mat_data = MTL_DICT[key] = ('%s'%fixName(key[0])), materialItems[f_mat], f_image
                            else:
                                mat_data = MTL_DICT[key] = ('%s_%s' % (fixName(key[0]), fixName(key[1]))), materialItems[f_mat], f_image
                        
                        if EXPORT_GROUP_BY_MAT:
                            file.write('g %s_%s_%s\n' % (fixName(ob.name), fixName(ob.getData(1)), mat_data[0]) ) # can be mat_image or (null)
                        file.write('usemtl %s\n' % mat_data[0]) # can be mat_image or (null)
                    
                contextMat = key
                if f_smooth != contextSmooth:
                    if f_smooth: # on now off
                        file.write('s 1\n')
                        contextSmooth = f_smooth
                    else: # was off now on
                        file.write('s off\n')
                        contextSmooth = f_smooth
                
                file.write('f')
                if faceuv and EXPORT_UV:
                    if EXPORT_NORMALS:
                        if f_smooth: # Smoothed, use vertex normals
                            for vi, v in enumerate(f_v):
                                file.write( ' %d/%d/%d' % (\
                                  v.index+totverts,\
                                  face_vert_index + vi,\
                                  globalNormals[ veckey3d(v.no) ])) # vert, uv, normal
                            
                        else: # No smoothing, face normals
                            no = globalNormals[ veckey3d(f.no) ]
                            for vi, v in enumerate(f_v):
                                file.write( ' %d/%d/%d' % (\
                                  v.index+totverts,\
                                  face_vert_index + vi,\
                                  no)) # vert, uv, normal
                    
                    else: # No Normals
                        for vi, v in enumerate(f_v):
                            file.write( ' %d/%d' % (\
                              v.index+totverts,\
                              face_vert_index + vi)) # vert, uv
                    
                    face_vert_index += len(f_v)
                
                else: # No UV's
                    if EXPORT_NORMALS:
                        if f_smooth: # Smoothed, use vertex normals
                            for v in f_v:
                                file.write( ' %d//%d' % (\
                                  v.index+totverts,\
                                  globalNormals[ veckey3d(v.no) ]))
                        else: # No smoothing, face normals
                            no = globalNormals[ veckey3d(f.no) ]
                            for v in f_v:
                                file.write( ' %d//%d' % (\
                                  v.index+totverts,\
                                  no))
                    else: # No Normals
                        for v in f_v:
                            file.write( ' %d' % (\
                              v.index+totverts))
                        
                file.write('\n')
            
            # Write edges.
            if EXPORT_EDGES:
                LOOSE= Mesh.EdgeFlags.LOOSE
                for ed in edges:
                    if ed.flag & LOOSE:
                        file.write('f %d %d\n' % (ed.v1.index+totverts, ed.v2.index+totverts))
                
            # Make the indicies global rather then per mesh
            totverts += len(me.verts)
            me.verts= None

#TODO: allow exporting of just actions with reference to a particular skeleton
    if EXPORT_ANIMATION:
        pass

    file.close()
    
    # Now we have all our materials, save them
# TODO: Redo material export
#    if EXPORT_MTL:
#        write_mtl(mtlfilename)
    if EXPORT_COPY_IMAGES:
        dest_dir = filename
        # Remove chars until we are just the path.
        while dest_dir and dest_dir[-1] not in '\\/':
            dest_dir = dest_dir[:-1]
        if dest_dir:
            copy_images(dest_dir)
        else:
            print '\tError: "%s" could not be used as a base for an image path.' % filename
    
    print "GMM Export time: %.2f" % (sys.time() - time1)
    
def write_armature(file, object):
    """Writes out GMM bone structure."""
    # TODO: give this its own button
    connections = list()
    arm = object.getData()
    arm_vec = Vector(object.getLocation())

    for bone in arm.bones.values():
        # Get absolute positions of bone head and tail
        hvec = bone.head['ARMATURESPACE'] + arm_vec
        tvec = bone.tail['ARMATURESPACE'] + arm_vec

        file.write('b %s %f %f %f %f %f %f\n' % \
                (bone.name, 
                 hvec[0], hvec[1], hvec[2],
                 tvec[0], tvec[1], tvec[2]))

        if(bone.hasParent()): # Don't make an entry for the root bone
            # cb parent child x x (connecting ends)
            # TODO: bone ends are hardcoded, find on which end a bone connects to its parent
            str = 'cb %s %s 1 0\n' % (bone.parent.name, bone.name)
            connections.append(str)

    # Print out all connections
    for i in connections:
        file.write(i)

    # Export actions as individual animations
    actions = NLA.GetActions()

    curves_rot = (PO_QUATX, PO_QUATY, PO_QUATZ, PO_QUATW)
    curves_loc = (PO_LOCX, PO_LOCY, PO_LOCZ)

    # Print positions and rotations for each key
    for act in actions.values():
        file.write('ani %s\n' % act.name)
        end_frame = max(act.getFrameNumbers())

        channel_ipos = act.getAllChannelIpos()
        ipo = channel_ipos['hand_L']
        frame = 0

        for ipo_name, ipo in channel_ipos.iteritems():
            keyframes_rot = list() # rotation
            keyframes_loc = set() # location

            # Get rotation keyframes for just QuatX, as all others should be the same
            if PO_QUATX in ipo:
                for p in ipo[PO_QUATX].bezierPoints:
                    keyframes_rot.append(int(p.pt[0])) # Truncate decimals
            keyframes_rot.sort()

            for curve in curves_loc:
                if curve in ipo:
                    for p in ipo[curve].bezierPoints:
                        keyframes_loc.add(int(p.pt[0]))
            keyframes_loc = list(keyframes_loc)  # Convert from set
            keyframes_loc.sort()

            # Write out rotations
            last_keyframe = 0
            for key in keyframes_rot:
                quat = Quaternion(ipo[PO_QUATW][key], ipo[PO_QUATX][key],
                        ipo[PO_QUATY][key], ipo[PO_QUATZ][key])
                euler = quat.toEuler()
                file.write('ar %s %i %i %f %f %f\n' 
                        % (ipo_name, last_keyframe, key, euler.x, euler.y, euler.z) )
                last_keyframe = key

            # Write out translations (if any)
            last_keyframe = 0
            for key in keyframes_loc:
                file.write('at %s %i %i %f %f %f\n' % (ipo_name, last_keyframe, key, 
                    ipo[PO_LOCX][key], ipo[PO_LOCY][key], ipo[PO_LOCZ][key]))
                last_keyframe = key

def write_ui(filename):
    
    if not filename.lower().endswith('.gmm'):
        filename += '.gmm'
    
    if not BPyMessages.Warning_SaveOver(filename):
        return
    
    EXPORT_APPLY_MODIFIERS = Draw.Create(1)
    EXPORT_ROTX90 = Draw.Create(1)
    EXPORT_TRI = Draw.Create(0)
    EXPORT_EDGES = Draw.Create(1)
    EXPORT_NORMALS = Draw.Create(0)
    EXPORT_NORMALS_HQ = Draw.Create(1)
    EXPORT_UV = Draw.Create(1)
    EXPORT_MTL = Draw.Create(0)
    EXPORT_SEL_ONLY = Draw.Create(1)
    EXPORT_ALL_SCENES = Draw.Create(0)
    EXPORT_ANIMATION = Draw.Create(1)
    EXPORT_COPY_IMAGES = Draw.Create(0)
    EXPORT_BLEN_OBS = Draw.Create(1)
    EXPORT_GROUP_BY_OB = Draw.Create(0)
    EXPORT_GROUP_BY_MAT = Draw.Create(0)
    EXPORT_MORPH_TARGET = Draw.Create(0)
    
    # removed too many options are bad!
    
    # Get USER Options
    pup_block = [\
    ('Context...'),\
    ('Selection Only', EXPORT_SEL_ONLY, 'Only export objects in visible selection. Else export whole scene.'),\
    ('All Scenes', EXPORT_ALL_SCENES, 'Each scene as a separate GMM file.'),\
    ('Animation', EXPORT_ANIMATION, 'Export bone structure and actions as animations.'),\
    ('Object Prefs...'),\
    ('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data from each object. May break vert order for morph targets.'),\
    ('Rotate X90', EXPORT_ROTX90 , 'Rotate on export so Blenders UP is translated into GMMs UP'),\
    ('Morph Target', EXPORT_MORPH_TARGET, 'Keep vert and face order, disables some other options.'),\
    ('Extra Data...'),\
    ('Edges', EXPORT_EDGES, 'Edges not connected to faces.'),\
    ('Normals', EXPORT_NORMALS, 'Export vertex normal data (Ignored on import).'),\
    ('High Quality Normals', EXPORT_NORMALS_HQ, 'Calculate high quality normals for rendering.'),\
    ('UVs', EXPORT_UV, 'Export texface UV coords.'),\
    ('Materials', EXPORT_MTL, 'Write a separate MTL file with the GMM.'),\
    ('Copy Images', EXPORT_COPY_IMAGES, 'Copy image files to the export directory, never overwrite.'),\
    ('Triangulate', EXPORT_TRI, 'Triangulate quads.'),\
    ('Grouping...'),\
    ('Objects', EXPORT_BLEN_OBS, 'Export blender objects as "GMM objects".'),\
    ('Object Groups', EXPORT_GROUP_BY_OB, 'Export blender objects as "GMM Groups".'),\
    ('Material Groups', EXPORT_GROUP_BY_MAT, 'Group by materials.'),\
    ]
    
    if not Draw.PupBlock('Export...', pup_block):
        return
    
    if EXPORT_MORPH_TARGET.val:
        EXPORT_BLEN_OBS.val = False
        EXPORT_GROUP_BY_OB.val = False
        EXPORT_GROUP_BY_MAT.val = False
        EXPORT_GROUP_BY_MAT.val = False
        EXPORT_APPLY_MODIFIERS.val = False
    
    Window.EditMode(0)
    Window.WaitCursor(1)
    
    EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val
    EXPORT_ROTX90 = EXPORT_ROTX90.val
    EXPORT_TRI = EXPORT_TRI.val
    EXPORT_EDGES = EXPORT_EDGES.val
    EXPORT_NORMALS = EXPORT_NORMALS.val
    EXPORT_NORMALS_HQ = EXPORT_NORMALS_HQ.val
    EXPORT_UV = EXPORT_UV.val
    EXPORT_MTL = EXPORT_MTL.val
    EXPORT_SEL_ONLY = EXPORT_SEL_ONLY.val
    EXPORT_ALL_SCENES = EXPORT_ALL_SCENES.val
    EXPORT_ANIMATION = EXPORT_ANIMATION.val
    EXPORT_COPY_IMAGES = EXPORT_COPY_IMAGES.val
    EXPORT_BLEN_OBS = EXPORT_BLEN_OBS.val
    EXPORT_GROUP_BY_OB = EXPORT_GROUP_BY_OB.val
    EXPORT_GROUP_BY_MAT = EXPORT_GROUP_BY_MAT.val
    EXPORT_MORPH_TARGET = EXPORT_MORPH_TARGET.val
    
    
    
    base_name, ext = splitExt(filename)
    context_name = [base_name, '', '', ext] # basename, scene_name, framenumber, extension
    
    # Use the options to export the data using write()
    # def write(filename, objects, EXPORT_EDGES=False, EXPORT_NORMALS=False, EXPORT_MTL=True, EXPORT_COPY_IMAGES=False, EXPORT_APPLY_MODIFIERS=True):
    orig_scene = Scene.GetCurrent()
    if EXPORT_ALL_SCENES:
        export_scenes = Scene.Get()
    else:
        export_scenes = [orig_scene]
    
    # Export all scenes.
    for scn in export_scenes:
        scn.makeCurrent() # If alredy current, this is not slow.
        context = scn.getRenderingContext()
        orig_frame = Blender.Get('curframe')
        
        if EXPORT_ALL_SCENES: # Add scene name into the context_name
            context_name[1] = '_%s' % BPySys.cleanName(scn.name) # WARNING, it's possible that this could cause a collision. we could fix if we're feeling paranoid.
        
        # Export an animation?
        if False: #TODO remove. EXPORT_ANIMATION:
            scene_frames = xrange(context.startFrame(), context.endFrame()+1) # up to and including the end frame.
        else:
            scene_frames = [orig_frame] # Dont export an animation.
        
        # Loop through all frames in the scene and export.
        for frame in scene_frames:
            #if EXPORT_ANIMATION: # Add frame to the filename.
            #    context_name[2] = '_%.6d' % frame
            
            Blender.Set('curframe', frame)
            if EXPORT_SEL_ONLY:
                export_objects = scn.objects.context
            else:   
                export_objects = scn.objects
            
            full_path= ''.join(context_name)
            
            if BPyMessages.Warning_SaveOver(full_path):
                # EXPORT THE FILE.
                write(full_path, export_objects,\
                EXPORT_TRI, EXPORT_EDGES, EXPORT_NORMALS,\
                EXPORT_NORMALS_HQ, EXPORT_UV, EXPORT_MTL,\
                EXPORT_COPY_IMAGES, EXPORT_APPLY_MODIFIERS,\
                EXPORT_ROTX90, EXPORT_BLEN_OBS,\
                EXPORT_GROUP_BY_OB, EXPORT_GROUP_BY_MAT, EXPORT_MORPH_TARGET,
                EXPORT_ANIMATION)
        
        Blender.Set('curframe', orig_frame)
    
    # Restore old active scene.
    orig_scene.makeCurrent()
    Window.WaitCursor(0)


if __name__ == '__main__':
    Window.FileSelector(write_ui, 'Export Galaxy Mage Mesh', sys.makename(ext='.gmm'))
